package com.divemotor.ventarepuestosinternet.controller;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import javax.annotation.PostConstruct;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ManagedProperty;
import javax.faces.bean.ViewScoped;

import org.apache.commons.collections.CollectionUtils;
import org.apache.log4j.Logger;
import org.primefaces.context.RequestContext;
import org.primefaces.model.DualListModel;

import com.divemotor.ventarepuestosinternet.beans.adapter.DataAdapter;
import com.divemotor.ventarepuestosinternet.beans.adapter.UsuarioInternoAdapter;
import com.divemotor.ventarepuestosinternet.beans.form.UsuarioInternoBeanForm;
import com.divemotor.ventarepuestosinternet.exception.DivemotorBusinessException;
import com.divemotor.ventarepuestosinternet.model.Administrador;
import com.divemotor.ventarepuestosinternet.model.Perfil;
import com.divemotor.ventarepuestosinternet.model.Sucursal;
import com.divemotor.ventarepuestosinternet.model.Supervisor;
import com.divemotor.ventarepuestosinternet.model.Usuario;
import com.divemotor.ventarepuestosinternet.model.Vendedor;
import com.divemotor.ventarepuestosinternet.service.AdministradorService;
import com.divemotor.ventarepuestosinternet.service.PerfilService;
import com.divemotor.ventarepuestosinternet.service.SucursalService;
import com.divemotor.ventarepuestosinternet.service.SupervisorService;
import com.divemotor.ventarepuestosinternet.service.UsuarioService;
import com.divemotor.ventarepuestosinternet.service.VendedorService;
import com.divemotor.ventarepuestosinternet.util.Constantes;
import com.divemotor.ventarepuestosinternet.util.Encriptacion;
import com.divemotor.ventarepuestosinternet.util.FacesContextUtil;

@ManagedBean(name="usuarioController")
@ViewScoped
public class UsuarioController implements Serializable {
	
	private static final Logger logger = Logger.getLogger(UsuarioController.class);

	private static final long serialVersionUID = -6342034294992274778L;
	
	@ManagedProperty(value = "#{perfilService}")
	private PerfilService perfilService;
	@ManagedProperty(value = "#{usuarioService}")
	private UsuarioService usuarioService;
	@ManagedProperty(value = "#{supervisorService}")
	private SupervisorService supervisorService;
	@ManagedProperty(value = "#{administradorService}")
	private AdministradorService administradorService;
	@ManagedProperty(value = "#{vendedorService}")
	private VendedorService vendedorService;
	@ManagedProperty(value = "#{sucursalService}")
	private SucursalService sucursalService;
	
	private UsuarioInternoBeanForm 		usuInternoForm;
	private UsuarioInternoAdapter  		usuInternoEliminar;
	private List<UsuarioInternoAdapter> listaUsuarios;
	private List<DataAdapter> 			listaPerfil;
	private boolean 					habilitarUsuario;
	private boolean 					habilitarCodigo;
	private boolean 					habilitarSucursal;
	
	private Usuario 					usuarioTmp;
	private List<Sucursal> 				listaSucursales;
	private DualListModel<Sucursal> 	dualListSucursales;
	private Integer 					idPerfil;
	private Integer 					idSucursal;
	private String 						repetirContrasenia; 
    private String 						estado;
    private String 						codigo;
    private Boolean 					pickDeshabilitado;
    private Boolean 					contraseniaDeshabilitadaEditar;
    
    private Administrador 				administradorEditar;
    private Supervisor 					supervisorEditar;
    private Vendedor 					vendedorEditar;
    private int 						tipoUsuario;
       
	public UsuarioController() {
		usuInternoForm					= new UsuarioInternoBeanForm();
		habilitarUsuario				= true;
		habilitarCodigo					= true;
		habilitarSucursal				= true;
        contraseniaDeshabilitadaEditar 	= true;
        idSucursal 		 				= Constantes.NO_SELECCIONADO;
        dualListSucursales				= new DualListModel<Sucursal>();
        usuarioTmp 						= new Usuario();
        administradorEditar 			= new Administrador();
        supervisorEditar 				= new Supervisor();
        vendedorEditar 					= new Vendedor();
	} 
	
	@PostConstruct
	void init() {
		buscarUsuarios();
		listarSucursalAdapter();
        listarPerfilesAdapter();
	}
	
	public void buscarUsuarios() {
		logger.info("buscarUsuarios");
		try {
			listaUsuarios = usuarioService.listarUsuariosInternos(usuInternoForm);
		} catch (Exception e) {
			logger.error("EX* buscarUsuarios: " + e.getMessage());
		}
	}
	
	private void listarPerfilesAdapter(){
		logger.info("listarPerfilesAdapter");
		try {
			listaPerfil = perfilService.listarPerfilesAdapter();
		} catch (Exception e) {
			logger.error("EX* cargarListas: " + e.getMessage());
		}
	}
	
	private void listarSucursalAdapter(){
		logger.info("listarPerfilesAdapter");
		try {
			listaSucursales = sucursalService.listarSucursales();
		} catch (Exception e) {
			logger.error("EX* cargarListas: " + e.getMessage());
		}
	}
	
	public void eliminarUsuario(){
		try {
			usuarioService.eliminarUsuarioInterno(usuInternoEliminar);
			buscarUsuarios();
			FacesContextUtil.info(Constantes.MSJ_USUARIO_ELIMINADO_OK);
			RequestContext.getCurrentInstance().addCallbackParam("idPerfil",Constantes.ID_PERFIL_SUPERVISOR);
		} catch (Exception e) {
			logger.error("EX* eliminarSupervisor Exception: " + e.getMessage());
			RequestContext.getCurrentInstance().addCallbackParam("ocurrioError", true);
			FacesContextUtil.error(Constantes.MSJ_ERROR_SISTEMA);
		}
	}
	
   public void limpiarFormularioNuevo(){
	  usuarioTmp 				= new Usuario();
	  repetirContrasenia 		= Constantes.EMPTY;
	  estado 					= Constantes.ESTADO_ACTIVO;
	  codigo 					= Constantes.EMPTY;
	  idSucursal 				= Constantes.NO_SELECCIONADO;
	  idPerfil 					= Constantes.ID_PERFIL_SUPERVISOR;
	  dualListSucursales 		= listarDualListSucursales();
      idSucursal 				= Constantes.NO_SELECCIONADO;
      configurarHabilitaciones(true, false, false, true);
   }
   
   public void buscarUsuarioNuevo() {
		try {
			String nickUsuario 	= usuarioTmp.getUsuario();
			Usuario usuario 	= usuarioService.obtenerUsuarioConPerfilesPorUsuarioLoginYSistema(nickUsuario);
			
			if (usuario != null) {
				
				usuarioTmp.setUsuario(nickUsuario);
				
				if (CollectionUtils.isNotEmpty(usuario.getAdministradores())) {
					Administrador administrador = usuario.getAdministradores().get(0);
					usuarioTmp 					= administrador.getUsuario();
					estado 						= administrador.getEstado();
					idSucursal 					= Constantes.NO_SELECCIONADO;
					idPerfil 					= Constantes.ID_PERFIL_ADMINISTRADOR;
				} else if (CollectionUtils.isNotEmpty(usuario.getSupervisores())) {
					Supervisor supervisor 		= usuario.getSupervisores().get(0);
					usuarioTmp 					= supervisor.getUsuario();
					codigo 						= supervisor.getCodigo();
					estado 						= supervisor.getEstado();
					dualListSucursales 			= obtenerDualistEditar(supervisor.getListaSucursal());
					idSucursal 					= Constantes.NO_SELECCIONADO;
					idPerfil 					= Constantes.ID_PERFIL_SUPERVISOR;
				} else if (CollectionUtils.isNotEmpty(usuario.getVendedores())) {
					Vendedor vendedor 			= usuario.getVendedores().get(0);
					usuarioTmp 					= vendedor.getUsuario();
					codigo 						= vendedor.getCodigo();
					estado 						= vendedor.getEstado();
					idSucursal 					= vendedor.getSucursal().getIdSucursal();
					dualListSucursales 			= listarDualListSucursales();
					idPerfil 					= Constantes.ID_PERFIL_VENDEDOR;
				}
				
				FacesContextUtil.warn(Constantes.MSJ_USUARIO_EN_USO);
			} else {
				limpiarFormularioNuevo();
				usuarioTmp.setUsuario(nickUsuario);
				configurarHabilitaciones(false, false, true, false);
			}
		} catch(Exception e) {
			logger.error("EX* buscarUsuarioNuevo: " + e.getMessage());
		}
	}
   
   public void configurarHabilitaciones(){
		if (idPerfil.equals(Constantes.ID_PERFIL_ADMINISTRADOR)) {
			configurarHabilitaciones(habilitarUsuario, false, false, true);
		} else if (idPerfil.equals(Constantes.ID_PERFIL_VENDEDOR)) {
			configurarHabilitaciones(habilitarUsuario, true, true, true);
		} else if (idPerfil.equals(Constantes.ID_PERFIL_SUPERVISOR)){
			configurarHabilitaciones(habilitarUsuario, false, true, false);
		}
   }
   
   private void configurarHabilitaciones(boolean habilitarUsuario, boolean habilitarSucursal, 
		   								 boolean habilitarCodigo, boolean pickDeshabilitado){
		this.habilitarUsuario  = habilitarUsuario;
		this.habilitarSucursal = habilitarSucursal;
		this.habilitarCodigo   = habilitarCodigo;
		this.pickDeshabilitado = pickDeshabilitado;
	}
  
   public DualListModel<Sucursal> listarDualListSucursales(){
	   List<Sucursal> source = new ArrayList<Sucursal>();  
       source.addAll(listaSucursales);
       return new DualListModel<Sucursal>(source, new ArrayList<Sucursal>());
   }
    
   public void guardarUsuario(){
		try {
			if (usuarioTmp.getContrasenia().equals(repetirContrasenia)) {
				
				usuarioTmp.setListaPerfiles(crearListaPerfiles(idPerfil));

				if (idPerfil.equals(Constantes.ID_PERFIL_ADMINISTRADOR)) {
					administradorService.insertar(crearAdministrador());
				} else if (idPerfil.equals(Constantes.ID_PERFIL_VENDEDOR)) {
					vendedorService.insertar(crearVendedor());
				} else if (idPerfil.equals(Constantes.ID_PERFIL_SUPERVISOR)) {
					supervisorService.insertar(crearSupervisor());
				}
				buscarUsuarios();
				FacesContextUtil.info(Constantes.MSJ_USUARIO_REGISTRO_OK);
			} else {
				RequestContext.getCurrentInstance().addCallbackParam("ocurrioError", true);
				FacesContextUtil.warn(Constantes.MSJ_CONTRASENIAS_DIFERENTES);
			}
		} catch (DivemotorBusinessException e) {
			logger.error("EX* guardarUsuarioAdministrador DivemotorBusinessException: " + e.getMessage());
			RequestContext.getCurrentInstance().addCallbackParam("ocurrioError", true);
			FacesContextUtil.warn(e.getMessage());
		} catch (Exception e) {
			logger.error("EX* guardarUsuarioAdministrador Exception: " + e.getMessage());
			RequestContext.getCurrentInstance().addCallbackParam("ocurrioError", true);
			FacesContextUtil.error(Constantes.MSJ_ERROR_SISTEMA);
		}
   }
   
   public void cargarDatosUsuarioEditar(UsuarioInternoAdapter usuarioEditar){
	    logger.info("cargarDatosUsuarioEditar");
		try {
			contraseniaDeshabilitadaEditar = false;
			tipoUsuario 			= usuarioEditar.getIdPerfil();
			codigo					= Constantes.EMPTY;

			String codigo 			= Constantes.EMPTY;
			String estado 			= Constantes.EMPTY;
			Integer idSucursal 		= Constantes.NO_SELECCIONADO;
			Integer idPerfil 		= Constantes.NO_SELECCIONADO;
			Usuario usuario 		= null;
			Integer idUsuarioPerfil = usuarioEditar.getIdUsuarioPerfil();

			if (tipoUsuario == Constantes.ID_PERFIL_ADMINISTRADOR) {
				idPerfil	 		= Constantes.ID_PERFIL_ADMINISTRADOR;
				administradorEditar = administradorService.obtenerPorId(idUsuarioPerfil);
				usuario 			= administradorEditar.getUsuario();
				estado 				= administradorEditar.getEstado();
				dualListSucursales 	= listarDualListSucursales();
			} else if (tipoUsuario == Constantes.ID_PERFIL_SUPERVISOR) {
				idPerfil	 		= Constantes.ID_PERFIL_SUPERVISOR;
				supervisorEditar 	= supervisorService.obtenerPorId(idUsuarioPerfil);
				usuario 			= supervisorEditar.getUsuario();
				codigo  			= supervisorEditar.getCodigo();
				estado  			= supervisorEditar.getEstado();
				dualListSucursales 	= obtenerDualistEditar(supervisorEditar.getListaSucursal());
			} else if (tipoUsuario == Constantes.ID_PERFIL_VENDEDOR) {
				idPerfil	 		= Constantes.ID_PERFIL_VENDEDOR;
				vendedorEditar		= vendedorService.obtenerPorId(idUsuarioPerfil);
				usuario 			= vendedorEditar.getUsuario();
				codigo 				= vendedorEditar.getCodigo();
				estado 				= vendedorEditar.getEstado();
				idSucursal 			= vendedorEditar.getSucursal().getIdSucursal();
				dualListSucursales 	= listarDualListSucursales();
			}

			iniciarDatosUsuarioEditar(usuario, codigo, estado, idSucursal, idPerfil);
			configurarHabilitaciones();
		} catch (Exception e) {
			logger.error("EX* cargarDatosUsuarioEditar Exception: " + e.getMessage());
			RequestContext.getCurrentInstance().addCallbackParam("ocurrioError", true);
			FacesContextUtil.error(Constantes.MSJ_ERROR_SISTEMA);
		}
   }
   
   private void iniciarDatosUsuarioEditar(Usuario usuarioEditar, String codigo, String estado, Integer sucursal, Integer Perfil){
	   this.usuarioTmp 			= usuarioEditar;
	   this.codigo				= codigo;
	   this.estado				= estado;
	   this.idSucursal	 		= sucursal;
	   this.idPerfil 			= Perfil;
   }
   
	private DualListModel<Sucursal> obtenerDualistEditar(List<Sucursal> listaSucursal) {
		List<Sucursal> source = new ArrayList<Sucursal>();
		List<Sucursal> target = new ArrayList<Sucursal>();

		source.addAll(listaSucursales);
		if (CollectionUtils.isNotEmpty(listaSucursal)) {
			target.addAll(listaSucursal);
			source.removeAll(target);
		}
//		if (CollectionUtils.isNotEmpty(listaSupervisorSucursal)) {
//			List<Sucursal> listaSucursal = new ArrayList<Sucursal>(listaSupervisorSucursal.size());
//			for(SupervisorSucursal supersal : listaSupervisorSucursal){
//				Sucursal sucursal = supersal.getSucursal();
//				sucursal.setEnvioCorreo(supersal.getIndEnviarCorreoBoolean());
//				listaSucursal.add(sucursal);
//			}
//			target.addAll(listaSucursal);
//			source.removeAll(target);
//		}
		return new DualListModel<Sucursal>(source, target);
	}

	public void actualizarUsuario() {
		try {
			if (contraseniaDeshabilitadaEditar && !repetirContrasenia.equals(usuarioTmp.getContrasenia())) {
				RequestContext.getCurrentInstance().addCallbackParam("ocurrioError", true);
				FacesContextUtil.warn(Constantes.MSJ_ERROR_CONTRASENIAS_DIFERENTES);
			} else {
				if (contraseniaDeshabilitadaEditar) {
					usuarioTmp.setContrasenia(Encriptacion.encriptarMD5(usuarioTmp.getContrasenia()));
				}
				if (idPerfil == Constantes.ID_PERFIL_ADMINISTRADOR) {
					actualizarAdministrador();
				} else if (idPerfil == Constantes.ID_PERFIL_VENDEDOR) {
					actualizarVendedor();
				} else if (idPerfil == Constantes.ID_PERFIL_SUPERVISOR) {
					actualizarSupervisor();
				}
				buscarUsuarios();
				FacesContextUtil.info(Constantes.MSJ_USUARIO_ACTUALIZADO_OK);
			}
		} catch (DivemotorBusinessException e) {
			logger.error("EX* actualizarUsuario DivemotorBusinessException: " + e.getMessage());
			RequestContext.getCurrentInstance().addCallbackParam("ocurrioError", true);
			FacesContextUtil.warn(e.getMessage());
		} catch (Exception e) {
			logger.error("EX* actualizarUsuario Exception: " + e.getMessage());
			RequestContext.getCurrentInstance().addCallbackParam("ocurrioError", true);
			FacesContextUtil.error(Constantes.MSJ_ERROR_SISTEMA);
		}
	}
  
    private void actualizarSupervisor() throws DivemotorBusinessException {
    	if(tipoUsuario == Constantes.ID_PERFIL_SUPERVISOR){
    		usuarioTmp.setListaPerfiles(crearListaPerfiles(Constantes.ID_PERFIL_SUPERVISOR));
    		Supervisor supervisor = crearSupervisor();
    		supervisor.setIdSupervisor(supervisorEditar.getIdSupervisor());
    	    supervisorService.actualizar(supervisor);
    	    RequestContext.getCurrentInstance().addCallbackParam("idPerfil", Constantes.ID_PERFIL_SUPERVISOR);
    	}else{
    		migrarUsuario();
    	}
    }

	private void actualizarVendedor() throws DivemotorBusinessException {
        if(tipoUsuario == Constantes.ID_PERFIL_VENDEDOR){	
        	usuarioTmp.setListaPerfiles(crearListaPerfiles(Constantes.ID_PERFIL_VENDEDOR));
        	Vendedor vendedor = crearVendedor();
        	vendedor.setIdVendedor(vendedorEditar.getIdVendedor());
    	    vendedorService.actualizar(vendedor);
    	    RequestContext.getCurrentInstance().addCallbackParam("idPerfil", Constantes.ID_PERFIL_VENDEDOR);
    	}else{
    		migrarUsuario();
    	}
    }

	private void actualizarAdministrador() throws DivemotorBusinessException {
        if(tipoUsuario == Constantes.ID_PERFIL_ADMINISTRADOR){
        	usuarioTmp.setListaPerfiles(crearListaPerfiles(Constantes.ID_PERFIL_ADMINISTRADOR));
        	Administrador administrador = crearAdministrador();
        	administrador.setIdAdministrador(administradorEditar.getIdAdministrador());
    	    administradorService.actualizar(administrador);
    	    RequestContext.getCurrentInstance().addCallbackParam("idPerfil", Constantes.ID_PERFIL_ADMINISTRADOR);
    	}else{
    		migrarUsuario();
    	}
    }
	
	private void migrarUsuario() throws DivemotorBusinessException {
	 	usuarioTmp.setListaPerfiles(crearListaPerfiles(idPerfil));
		 
	   if(idPerfil.equals(Constantes.ID_PERFIL_ADMINISTRADOR)){
     		administradorService.migrarUsuario(tipoUsuario, crearAdministrador());
     		RequestContext.getCurrentInstance().addCallbackParam("idPerfil", Constantes.ID_PERFIL_ADMINISTRADOR);   
	   }else if(idPerfil.equals(Constantes.ID_PERFIL_VENDEDOR)){  	
            vendedorService.migrarUsuario(tipoUsuario, crearVendedor());
            RequestContext.getCurrentInstance().addCallbackParam("idPerfil", Constantes.ID_PERFIL_VENDEDOR);
	   }else if(idPerfil.equals(Constantes.ID_PERFIL_SUPERVISOR)){
    		supervisorService.migrarUsuario(tipoUsuario,crearSupervisor());
    		RequestContext.getCurrentInstance().addCallbackParam("idPerfil", Constantes.ID_PERFIL_SUPERVISOR);
	   }
	}

	private List<Perfil> crearListaPerfiles(Integer idPerfil) {
		Perfil perfil = new Perfil();
		perfil.setIdPerfil(idPerfil);
		List<Perfil> listaPerfil = new ArrayList<Perfil>();
		listaPerfil.add(perfil);
		return listaPerfil;
	}

	private Administrador crearAdministrador() {
		Administrador admin = new Administrador();
		admin.setEstado(estado);
		admin.setUsuario(usuarioTmp);
		return admin;
	}

	private Vendedor crearVendedor() {
		Vendedor vendedor = new Vendedor();
		vendedor.setEstado(estado);
		vendedor.setCodigo(codigo);
		vendedor.setUsuario(usuarioTmp);
		Sucursal sucu = new Sucursal();
		sucu.setIdSucursal(idSucursal);
		vendedor.setSucursal(sucu);
		return vendedor;
	}

	private Supervisor crearSupervisor() {
		Supervisor supervisor = new Supervisor();
		supervisor.setCodigo(codigo);
		supervisor.setEstado(estado);
		
//		List<SupervisorSucursal> listaSupervisorSucursal = null;
//		if(CollectionUtils.isNotEmpty(lstSucu)){
//			listaSupervisorSucursal =  new ArrayList<SupervisorSucursal>(lstSucu.size());
//			for(Sucursal sucursal : lstSucu){
//				SupervisorSucursal superSucursal = new SupervisorSucursal();
//				superSucursal.setIndEnviarCorreoBoolean(sucursal.getEnvioCorreo());
//				superSucursal.setSucursal(sucursal);
//				superSucursal.setSupervisor(supervisor);
//				listaSupervisorSucursal.add(superSucursal);
//			}
//		}
//		supervisor.setSucursales(listaSupervisorSucursal);
		
		supervisor.setListaSucursal(dualListSucursales.getTarget());
		supervisor.setEstado(estado);
		supervisor.setUsuario(usuarioTmp);
		return supervisor;
	}

    public void limpiarFiltro(){
	   usuInternoForm.limpiarForm();
    }
   
	public Usuario getUsuarioNuevo() {
		return usuarioTmp;
	}

	public void setUsuarioNuevo(Usuario usuarioNuevo) {
		this.usuarioTmp = usuarioNuevo;
	}

	public List<Sucursal> getListaSucursales() {
		return listaSucursales;
	}

	public void setListaSucursales(List<Sucursal> listaSucursales) {
		this.listaSucursales = listaSucursales;
	}

	public void setPerfilService(PerfilService perfilService) {
		this.perfilService = perfilService;
	}

	public void setUsuarioService(UsuarioService usuarioService) {
		this.usuarioService = usuarioService;
	}

	public void setSupervisorService(SupervisorService supervisorService) {
		this.supervisorService = supervisorService;
	}

	public void setAdministradorService(AdministradorService administradorService) {
		this.administradorService = administradorService;
	}

	public void setSucursalService(SucursalService sucursalService) {
		this.sucursalService = sucursalService;
	}

	public String getRepetirContrasenia() {
		return repetirContrasenia;
	}

	public void setRepetirContrasenia(String repetirContrasenia) {
		this.repetirContrasenia = repetirContrasenia;
	}

	public Integer getIdSucursal() {
		return idSucursal;
	}

	public void setIdSucursal(Integer idSucursal) {
		this.idSucursal = idSucursal;
	}

	public String getEstado() {
		return estado;
	}

	public void setEstado(String estado) {
		this.estado = estado;
	}

	public String getCodigo() {
		return codigo;
	}

	public void setCodigo(String codigo) {
		this.codigo = codigo;
	}

	public Integer getIdPerfil() {
		return idPerfil;
	}

	public void setIdPerfil(Integer idPerfil) {
		this.idPerfil = idPerfil;
	}

	public DualListModel<Sucursal> getDualListSucursales() {
		return dualListSucursales;
	}

	public void setDualListSucursales(DualListModel<Sucursal> dualListSucursales) {
		this.dualListSucursales = dualListSucursales;
	}

	public Boolean getPickDeshabilitado() {
		return pickDeshabilitado;
	}

	public void setPickDeshabilitado(Boolean pickDeshabilitado) {
		this.pickDeshabilitado = pickDeshabilitado;
	}

	public void setVendedorService(VendedorService vendedorService) {
		this.vendedorService = vendedorService;
	}

	public Administrador getAdministradorEditar() {
		return administradorEditar;
	}

	public void setAdministradorEditar(Administrador administradorEditar) {
		this.administradorEditar = administradorEditar;
	}

	public Supervisor getSupervisorEditar() {
		return supervisorEditar;
	}

	public void setSupervisorEditar(Supervisor supervisorEditar) {
		this.supervisorEditar = supervisorEditar;
	}

	public Vendedor getVendedorEditar() {
		return vendedorEditar;
	}

	public void setVendedorEditar(Vendedor vendedorEditar) {
		this.vendedorEditar = vendedorEditar;
	}

	public Boolean getContraseniaDeshabilitadaEditar() {
		return contraseniaDeshabilitadaEditar;
	}

	public void setContraseniaDeshabilitadaEditar(Boolean contraseniaDeshabilitadaEditar) {
		this.contraseniaDeshabilitadaEditar = contraseniaDeshabilitadaEditar;
	}

	public Integer getTipoDeusuario() {
		return tipoUsuario;
	}

	public void setTipoDeusuario(Integer tipoDeusuario) {
		this.tipoUsuario = tipoDeusuario;
	}

	public UsuarioInternoBeanForm getUsuInternoForm() {
		return usuInternoForm;
	}

	public void setUsuInternoForm(UsuarioInternoBeanForm usuInternoForm) {
		this.usuInternoForm = usuInternoForm;
	}

	public List<UsuarioInternoAdapter> getListaUsuarios() {
		return listaUsuarios;
	}

	public void setListaUsuarios(List<UsuarioInternoAdapter> listaUsuarios) {
		this.listaUsuarios = listaUsuarios;
	}

	public List<DataAdapter> getListaPerfil() {
		return listaPerfil;
	}

	public void setListaPerfil(List<DataAdapter> listaPerfil) {
		this.listaPerfil = listaPerfil;
	}

	public UsuarioInternoAdapter getUsuInternoEliminar() {
		return usuInternoEliminar;
	}

	public void setUsuInternoEliminar(UsuarioInternoAdapter usuInternoEliminar) {
		this.usuInternoEliminar = usuInternoEliminar;
	}

	public boolean isHabilitarUsuario() {
		return habilitarUsuario;
	}

	public void setHabilitarUsuario(boolean habilitarUsuario) {
		this.habilitarUsuario = habilitarUsuario;
	}

	public boolean isHabilitarCodigo() {
		return habilitarCodigo;
	}

	public void setHabilitarCodigo(boolean habilitarCodigo) {
		this.habilitarCodigo = habilitarCodigo;
	}

	public boolean isHabilitarSucursal() {
		return habilitarSucursal;
	}

	public void setHabilitarSucursal(boolean habilitarSucursal) {
		this.habilitarSucursal = habilitarSucursal;
	}

	public Usuario getUsuarioTmp() {
		return usuarioTmp;
	}

	public void setUsuarioTmp(Usuario usuarioTmp) {
		this.usuarioTmp = usuarioTmp;
	}
}
